#ifndef __M_UTIL_H__
#define __M_UTIL_H__

#include "logger.hpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <memory>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>

// 这里也把两个头文件先包进来，后续使用这个util工具类就可以直接使用了
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>

class mysql_util
{
public:
    // 在mysql_util这个类里面，封装实现了静态方法mysql_create，用于创建并初始化mysql句柄，以及设置好客户端的字符集等工作。
    static MYSQL *mysql_create(const std::string &host,
                               const std::string &username,
                               const std::string &password,
                               const std::string &dbname,
                               const uint16_t &port = 3306)
    {
        // 初始化句柄
        MYSQL *mysql = mysql_init(NULL);
        if (mysql == nullptr)
        {
            ELOG("mysql init failed!");
            return nullptr;
        }

        // 连接
        if (mysql_real_connect(mysql, host.c_str(), username.c_str(), password.c_str(), dbname.c_str(), port, nullptr, 0) == nullptr)
        {
            ELOG("mysql real failed: %s", mysql_errno(mysql));
            mysql_close(mysql);
            return nullptr;
        }

        // 设置客户端字符集
        if (mysql_set_character_set(mysql, "utf8") != 0)
        {
            ELOG("mysql set character: %s", mysql_errno(mysql));
            mysql_close(mysql);
            return nullptr;
        }
        return mysql;
    }

    // mysql_exec用于执行mysql语句，但这个接口的封装实现只能执行插入，更新和删除语句，因为只有这三个语句的执行逻辑是一样的
    static bool mysql_exec(MYSQL *mysql, const std::string &sql)
    {
        int ret = mysql_query(mysql, sql.c_str());
        if (ret != 0)
        {
            ELOG("%s sql query failed: %s", sql.c_str(), mysql_error(mysql));
            // 这里执行失败就先不要释放句柄了，将来db.hpp的user_table对象在析构时会释放句柄，重复释放则出现野指针访问了
            return false;
        }
        return true;
    }

    // mysql_destroy用于释放销毁mysql句柄
    static void mysql_destroy(MYSQL *mysql)
    {
        if (mysql)
            mysql_close(mysql);
    }
};

// 在json_util这里，封装实现序列化和反序列化的静态方法即可
// 在序列化接口里面，需要外部传入一个root对象和一个str对象
// 在内部我们会将root中的json格式的数据组织成为一个string对象，然后将这个对象赋值给str输出型参数
// 外部就可以拿到序列化后的字符串str了。
class json_util
{
public:
    static bool serialize(const Json::Value &root, std::string &str)
    {
        Json::StreamWriterBuilder swb;
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());

        std::stringstream ss;
        int ret = sw->write(root, &ss);

        if (ret != 0)
        {
            ELOG("Json::serialize failed!");
            return false;
        }

        str = ss.str();
        return true;
    }

    static bool deserialize(const std::string &str, Json::Value &root)
    {
        Json::CharReaderBuilder crb;
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());

        std::string err;
        bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
        if (!ret)
        {
            ELOG("Json::deserialize failed: %s!", err.c_str());
            return false;
        }
        return true;
    }
};

class string_util
{
public:
    static void split(const std::string &src, const std::string &sep, std::vector<std::string> &res)
    {
        size_t pos = 0, idx = 0;
        while (idx != std::string::npos)
        {
            idx = src.find(sep, pos);
            if (pos != idx)
            {
                res.push_back(src.substr(pos, idx - pos));
                pos = idx + sep.size();
            }
        }
        return;
    }
};

class file_util
{
public:
    static bool read(const std::string filename, std::string &body)
    {
        // 1. 打开文件
        std::ifstream ifs(filename, std::ios::binary | std::ios::in);
        if (ifs.is_open() == false)
        {
            ELOG("%s open failed!!!", filename.c_str());
            return false;
        }

        // 2. 获取文件大小
        ifs.seekg(0, std::ios::end);
        size_t fsize = ifs.tellg();
        ifs.seekg(0, std::ios::beg);

        body.resize(fsize);

        // 3. 读取文件内容
        ifs.read(&body[0], fsize);

        if (ifs.good() == false)
        {
            ELOG("%s read failed!", filename.c_str());
            ifs.close();
            return false;
        }

        // 4. 关闭文件
        ifs.close();
        return true;
    }
};

#endif